Processamento de Linguagem Natural

1 O que é NLP?

Ensinar máquinas a entender a linguagem humana — um dos problemas mais difíceis da IA.

Por que NLP é difícil?

O que NLP resolve?

2 Tokenização — texto vira números

O primeiro passo de qualquer modelo de linguagem: transformar texto em unidades processáveis.

Abordagens de tokenização

🎮 Simulador de Tokenização BPE

Por que subword é o padrão?

Código Python: tokenização com Hugging Face

from transformers import AutoTokenizer

# Carrega tokenizador do GPT-2 (BPE)
tokenizer = AutoTokenizer.from_pretrained("gpt2")

# Tokeniza um texto
text = "A tokenização é fundamental para LLMs"
tokens = tokenizer(text)

print(f"Tokens: {tokens.tokens()}")
# ['A', ' token', 'ização', ' é', ' fundamental', ' para', ' L', 'LM', 's']

print(f"IDs: {tokens['input_ids']}")
# [32, 3797, 4672, 318, 16385, 3518, 40, 1842, 2]

# Cada token tem um ID numérico único
# Esses IDs viram a entrada da rede neural

3 Bag of Words e TF-IDF

As primeiras formas de transformar texto em números — simples, mas limitadas.

Bag of Words (BoW)

Cada documento vira um vetor onde cada posição representa uma palavra do vocabulário, e o valor é a contagem dessa palavra no documento.

# Exemplo: 3 documentos
doc1 = "o gato comeu o rato"
doc2 = "o rato fugiu do gato"
doc3 = "o gato dormiu"

# Vocabulário: [o, gato, comeu, rato, fugiu, do, dormiu]

# Representação BoW:
doc1_vec = [2, 1, 1, 1, 0, 0, 0]  # "o" aparece 2x, "gato" 1x, etc.
doc2_vec = [1, 1, 0, 1, 1, 1, 0]
doc3_vec = [1, 1, 0, 0, 0, 0, 1]

O problema: palavras comuns dominam

"o", "de", "para" aparecem em quase todos os documentos — não carregam informação útil. TF-IDF resolve isso.

TF-IDF (Term Frequency - Inverse Document Frequency)

Pesa cada palavra por:

• TF: frequência da palavra no documento (quanto mais, mais importante)
• IDF: inverso da frequência nos documentos (quanto mais rara, mais importante)

TF-IDF = TF(t,d) × IDF(t)

# Onde:
TF(t,d) = contagem de t em d / total de palavras em d
IDF(t) = log(total de docs / docs que contêm t)

🎮 Simulador de TF-IDF

Código Python: TF-IDF com scikit-learn

from sklearn.feature_extraction.text import TfidfVectorizer

# Documentos da Nimbus Cloud
docs = [
    "timeout no endpoint /v2/sync após 30 segundos",
    "API v3.2 documentação autenticação JWT",
    "runbook aumentar NIMBUS_TIMEOUT para 120 segundos"
]

# Cria vetorizador TF-IDF
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(docs)

# Mostra palavras e seus pesos
feature_names = vectorizer.get_feature_names_out()
for i, doc in enumerate(docs):
    print(f"\nDoc {i+1}: {doc}")
    for j in tfidf_matrix[i].nonzero()[1]:
        print(f"  {feature_names[j]}: {tfidf_matrix[i, j]:.3f}")

Limitações de BoW e TF-IDF

4 Word2Vec — os primeiros embeddings

A revolução de 2013: palavras viram vetores densos que capturam significado.

Como funciona o Word2Vec

Dois algoritmos principais:

🎮 Mapa 2D de palavras (Word2Vec)

O famoso exemplo: rei - homem + mulher = rainha

import numpy as np
from gensim.models import KeyedVectors

# Carrega modelo Word2Vec pré-treinado
model = KeyedVectors.load_word2vec_format('word2vec-google-news-300.gz')

# Analogia: rei - homem + mulher = ?
result = model.most_similar(
    positive=['rei', 'mulher'],
    negative=['homem']
)

print(result[0])
# ('rainha', 0.71) ← a palavra mais próxima é "rainha"!

# Outras analogias funcionam:
# Paris - França + Itália = Roma
# Tóquio - Japão + China = Pequim

Por que Word2Vec foi revolucionário?

Limitações do Word2Vec

5 RNNs e LSTMs — processando sequências

Redes neurais que lembram do passado — a base do NLP moderno antes dos Transformers.

Como funciona uma RNN

A cada passo t, a RNN:

1. Recebe o input atual x[t] (token atual)
2. Recebe o estado oculto anterior h[t-1] (memória)
3. Calcula o novo estado oculto h[t] = f(W*x[t] + U*h[t-1] + b)
4. Usa h[t] para fazer previsão ou passar para o próximo passo

🎮 Visualização: RNN processando uma frase

O problema das RNNs: dependências de longo alcance

LSTM: as 3 portas mágicas

Código Python: LSTM com PyTorch

import torch
import torch.nn as nn

class SentimentLSTM(nn.Module):
    def __init__(self, vocab_size, embed_dim=100, hidden_dim=128):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, 1)  # binary classification

    def forward(self, x):
        # x shape: (batch, seq_len)
        embedded = self.embedding(x)  # (batch, seq_len, embed_dim)

        # LSTM processa a sequência
        output, (hidden, cell) = self.lstm(embedded)

        # Usa o último estado oculto para classificação
        out = self.fc(hidden.squeeze(0))
        return torch.sigmoid(out)

# Uso
model = SentimentLSTM(vocab_size=10000)
tokens = torch.tensor([[5, 23, 142, 87, 3]])  # sequência de tokens
output = model(tokens)
print(f"Sentimento: {output.item():.2f}")  # 0.82 → positivo

RNNs vs LSTMs vs GRUs

6 O problema das dependências de longo alcance

Por que RNNs falham em frases longas — e como isso motivou os Transformers.

Exemplo prático

# Frase longa com dependência distante
"O contrato que assinamos em janeiro após meses de negociação
com o fornecedor e revisão jurídica finalmente foi aprovado
pelo conselho e publicado no diário oficial em março e agora
precisamos saber quando ele vence."

# Pergunta: "quando o contrato vence?"
# Resposta está em "março" — mas está a 50+ palavras de distância!

# RNN/LSTM:
# - Processa palavra por palavra
# - Quando chega em "vence", já "esqueceu" parcialmente "março"
# - Mesmo LSTM tem dificuldade com 50+ palavras

# Transformer (próximo módulo):
# - Conecta TODAS as palavras diretamente (self-attention)
# - "vence" pode "olhar" diretamente para "março"
# - Não importa a distância

Por que isso importa para RAG?

Em RAG, os chunks podem ter 300-500 tokens. Se o modelo não consegue capturar dependências de longo alcance, vai perder informação importante dentro do próprio chunk.

7 Conexão com RAG

Como tudo que você aprendeu aqui se aplica ao Módulo 7 (RAG).

Conceitos que se conectam

Evolução do NLP até os LLMs

🎯 Quiz — teste seu conhecimento

Clique em uma alternativa para ver se acertou.

→ O que vem a seguir?

Agora que você entende NLP clássico, vamos mergulhar na arquitetura que mudou tudo.

Conceitos que vamos construir aqui